package org.dromara.common.encrypt.interceptor;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.encrypt.annotation.EncryptField;
import org.dromara.common.encrypt.core.EncryptContext;
import org.dromara.common.encrypt.core.EncryptorManager;
import org.dromara.common.encrypt.enumd.AlgorithmType;
import org.dromara.common.encrypt.enumd.EncodeType;
import org.dromara.common.encrypt.properties.EncryptorProperties;

import java.lang.reflect.Field;
import java.sql.PreparedStatement;
import java.util.*;


/**
 * @Author 刘武贵
 * @Date 2024/8/15 22:00
 * @Description 功能描述：入参加密拦截器
 */
@Slf4j
// 该注释用于指定一个拦截器，拦截特定类型的对象调用特定方法时的行为
@Intercepts({@Signature(
    // 指定被拦截对象的类型
    type = ParameterHandler.class,
    // 指定被拦截的方法名
    method = "setParameters",
    // 指定被拦截方法的参数类型
    args = {PreparedStatement.class})
})
@AllArgsConstructor
/**
 * 实现Interceptor接口的加密字段拦截器类
 * 该拦截器用于在Mybatis操作数据库时，自动处理指定字段的加解密工作
 * 主要目的是为了保护敏感数据的安全，避免直接以明文形式存储在数据库中
 */
public class MybatisEncryptInterceptor implements Interceptor {

    /**
     * 加密管理类
     */
    private final EncryptorManager encryptorManager;

    /**
     * 加解密属性配置类
     */
    private final EncryptorProperties defaultProperties;

    /**
     * 拦截器方法，用于拦截调用
     * 此方法在调用链中传递调用对象，不进行任何操作
     *
     * @param invocation 调用对象，包含调用链信息
     * @return 直接返回调用对象本身
     * @throws Throwable 可能抛出的异常
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        return invocation;
    }

    /**
     * 插件加载方法，用于在目标对象上应用加密操作
     * 此方法检查目标对象是否为参数处理器，如果是，则对参数对象进行加密
     *
     * @param target 目标对象，可能是参数处理器或其他对象
     * @return 返回目标对象本身
     */
    @Override
    public Object plugin(Object target) {
        // 判断目标对象是否为参数处理器
        if (target instanceof ParameterHandler parameterHandler) {
            // 进行加密操作
            // 获取参数对象，准备进行加密操作
            Object parameterObject = parameterHandler.getParameterObject();
            // 检查参数对象是否非空且不是字符串类型，避免对空值或字符串进行加密
            if (ObjectUtil.isNotNull(parameterObject) && !(parameterObject instanceof String)) {
                // 对参数对象进行加密处理
                this.encryptHandler(parameterObject);
            }
        }
        return target;
    }

    /**
     * 加密对象，递归地处理和加密对象中的敏感信息
     *
     * @param sourceObject 待加密对象，可能包含需要加密的数据
     */
    private void encryptHandler(Object sourceObject) {
        if (ObjectUtil.isNull(sourceObject)) {
            return;
        }

        // 如果对象是一个Map，对其值进行递归处理
        if (sourceObject instanceof Map<?, ?> map) {
            new HashSet<>(map.values()).forEach(this::encryptHandler);
            return;
        }

        // 如果对象是一个List，检查并对其元素进行递归处理
        if (sourceObject instanceof List<?> list) {
            if(CollUtil.isEmpty(list)) {
                return;
            }
            // 判断第一个元素是否含有注解。如果没有直接返回，提高效率
            Object firstItem = list.get(0);
            if (ObjectUtil.isNull(firstItem) || CollUtil.isEmpty(encryptorManager.getFieldCache(firstItem.getClass()))) {
                return;
            }
            list.forEach(this::encryptHandler);
            return;
        }

        // 不在缓存中的类,就是没有加密注解的类(当然也有可能是typeAliasesPackage写错)
        Set<Field> fields = encryptorManager.getFieldCache(sourceObject.getClass());
        if(ObjectUtil.isNull(fields)){
            return;
        }

        // 尝试获取并加密对象中的敏感字段
        try {
            for (Field field : fields) {
                // 加密字段值，并更新回原对象
                field.set(sourceObject, this.encryptField(Convert.toStr(field.get(sourceObject)), field));
            }
        } catch (Exception e) {
            log.error("处理加密字段时出错", e);
        }
    }

    /**
     * 字段值进行加密。通过字段的批注注册新的加密算法
     * 加密字段值
     *
     * @param value 待加密的值
     * @param field 待加密字段
     * @return 加密后结果
     */
    private String encryptField(String value, Field field) {
        if (ObjectUtil.isNull(value)) {
            return null;
        }
        // 获取字段上的EncryptField注解
        EncryptField encryptField = field.getAnnotation(EncryptField.class);

        // 初始化加密上下文
        EncryptContext encryptContext = new EncryptContext();

        // 设置加密算法，如果注解中指定了默认算法，则使用默认属性中的算法
        encryptContext.setAlgorithm(encryptField.algorithm() == AlgorithmType.DEFAULT ? defaultProperties.getAlgorithm() : encryptField.algorithm());

        // 设置加密编码，如果注解中指定了默认编码，则使用默认属性中的编码
        encryptContext.setEncode(encryptField.encode() == EncodeType.DEFAULT ? defaultProperties.getEncode() : encryptField.encode());

        // 设置加密密码，如果注解中未指定密码，则使用默认属性中的密码
        encryptContext.setPassword(StringUtils.isBlank(encryptField.password()) ? defaultProperties.getPassword() : encryptField.password());

        // 设置私钥，如果注解中未指定私钥，则使用默认属性中的私钥
        encryptContext.setPrivateKey(StringUtils.isBlank(encryptField.privateKey()) ? defaultProperties.getPrivateKey() : encryptField.privateKey());

        // 设置公钥，如果注解中未指定公钥，则使用默认属性中的公钥
        encryptContext.setPublicKey(StringUtils.isBlank(encryptField.publicKey()) ? defaultProperties.getPublicKey() : encryptField.publicKey());

        // 调用加密管理器进行加密操作
        return this.encryptorManager.encrypt(value, encryptContext);
    }

    /**
     * 设置属性该方法目前未实现具体功能
     *
     * @param properties 属性对象
     */
    @Override
    public void setProperties(Properties properties) {
    }
}
